﻿#include "kexpressionbuffer.h"

//添加一个 token（如数字、符号）
void ExpressionBuffer::append(const QString& token) {
    if (minusAppend(token)) return;
    m_tokens.push(token);
    clearRedoStack(); //清除 redo 栈
}

//将当前表达式包裹为 1/(...)
void ExpressionBuffer::wrapWithInverse() {
    if (m_tokens.isEmpty()) return;
    m_processStack.push(m_tokens);
    clearRedoStack();
    QString expr = toString();
    m_tokens.clear();
    m_tokens.push("1/(" + expr + ")");
}

//将当前表达式包裹为 -1*(...)
void ExpressionBuffer::wrapWithNegate() {
    if (m_tokens.isEmpty()) return;
    m_processStack.push(m_tokens);
    clearRedoStack();
    QString expr = toString();
    m_tokens.clear();
    m_tokens.push("-1*(" + expr + ")");
}

//撤销上一步操作（支持多级）
void ExpressionBuffer::undo() {
    if (!m_tokens.isEmpty()) {
        m_redoStack.push(m_tokens);  
        m_tokens.pop();  
        if (m_tokens.isEmpty() && !m_processStack.isEmpty()) {
            m_tokens = m_processStack.pop();  //如果撤回后为空，恢复上一次表达式
        }
    }
    else if (!m_processStack.isEmpty()) {
        m_redoStack.push(m_tokens);   
        m_tokens = m_processStack.pop();  //从历史记录中恢复上一个表达式
    }
}

//重做上一步被撤销的操作
void ExpressionBuffer::redo() {
    if (!m_redoStack.isEmpty()) {
        m_processStack.push(m_tokens);
        m_tokens = m_redoStack.pop();
    }
}

//清空 redo 栈（每次新操作后调用）
void ExpressionBuffer::clearRedoStack() {
    m_redoStack.clear();
}


//处理带负号的特殊逻辑，比如 (-3)
bool ExpressionBuffer::minusAppend(const QString& token) {
	// 只处理 - 的情况
    if (token == "-" && m_minusCount == 0) {
        if (m_tokens.isEmpty() || m_tokens.top() == "(" ) {
            // 表达式开头，认为是负号
            m_tokens.push("-1*");
            clearRedoStack();
            return true;
        }
        // 如果上一个 token 是左括号或二元运算符才视作负号
        if (isBinaryOperator(m_tokens.top())) {
            m_tokens.push("(-");
            m_minusCount++;
            clearRedoStack();
            return true;
        }

    }
    else if (m_minusCount > 0) {
        //小数点和数字不影响
        if (isNumber(token) || token == ".") {
            m_tokens.push(token);
            clearRedoStack();
            return true;
        }
        //遇到非数字时自动闭合括号
        m_tokens.push(")");
        m_minusCount--;
        return false;
    }
    return false;
}



//清空表达式及 redo 栈
void ExpressionBuffer::clear() {
    m_tokens.clear();
    clearRedoStack();
}

//清空表达式历史栈
void ExpressionBuffer::clearProcess() {
    m_processStack.clear();
}

//拼接所有 token 成为字符串表达式
QString ExpressionBuffer::toString() const {
    QString result;
    for (const QString& token : m_tokens) {
        result += token;
    }
    return result;
}

//获取显示字符串：将内部表达式转为可读格式
QString ExpressionBuffer::toDisplayString() const {
    QString expr = toString();
    expr.replace("sqrt", QStringLiteral("\u221A"));
    expr.replace("^2", QChar(0x00B2));
    expr.replace("-1*", "-");
    return expr;
}

//判断表达式是否为空
bool ExpressionBuffer::isEmpty() const {
    return m_tokens.isEmpty();
}

//将当前表达式压入操作历史栈（用于多级撤销）
void ExpressionBuffer::pushProcess() {
    if (!m_tokens.isEmpty()) {
        m_processStack.push(m_tokens);
        clearRedoStack();
    }
}

//判断是否是二元运算符
bool ExpressionBuffer::isBinaryOperator(const QString& token) const {
    return token == "+" || token == "-" || token == "*" || token == "/";
}

//判断是否为数字（支持浮点数）
bool ExpressionBuffer::isNumber(const QString& token) const {
    bool ok;
    token.toDouble(&ok);
    return ok;
}

//获取当前未闭合负号的数量
int ExpressionBuffer::getMinusCount() {
    return m_minusCount;
}

//重置负号状态（如在清除表达式后）
void ExpressionBuffer::clearMinus() {
    m_minusCount = 0;
}
